use std::cell::{Ref, RefCell};
use std::mem::replace;
use std::ops::Deref;

//对外开放使用
#[derive(Debug)]
pub struct ForwardList<T>
where
    T: Sized,
{
    head: Link<T>,
}
// 使用类型优化
type Link<T> = Option<Box<Node<T>>>;

// #[derive(Debug)]
// enum Link<T>
// where
//     T: Sized,
// {
//     EMPTY,
//     MORE(Box<Node<T>>),
// }

#[derive(Debug)]
struct Node<T>
where
    T: Sized,
{
    value: T,      //值
    next: Link<T>, //节点下一个元素用enum全涵盖，要么空，要么是下一个不为空节点
}

impl<T> ForwardList<T>
where
    T: Sized,
{
    // 初始空头节点
    pub fn new() -> ForwardList<T> {
        ForwardList { head: None }
    }

    // 插入头节点(头插法)
    pub fn push_head(&mut self, value: T) -> &mut Self {
        // 在&mut下不可以让出T中元素的所有权
        self.head = Some(Box::new(Node {
            value,
            // next: std::mem::replace(&mut self.head, None),
            next: self.head.take(),
        }));
        self
    }

    // 弹出头节点
    pub fn pop_head(&mut self) -> Option<T> {
        self.head.take().map(|node| {
            self.head = node.next;
            node.value
        })
        // std::mem::replace(&mut self.head, None).map(|node| {
        //     self.head = node.next;
        //     node.value
        // })

        // match std::mem::replace(&mut self.head, None) {
        //     Link::EMPTY => None,
        //     Link::MORE(node) => {
        //         self.head = node.next;
        //         Some(node.value)
        //     }
        // }
    }

    // 查看头部元素
    pub fn peek(&self) -> Option<&T> {
        // as_ref OP<T> => OP<&T>         一般用于获取内部引用配合map对元素映射处理
        // as_deref OP<T> => OP<&T:Target> 一般用于Box类智能指针
        self.head.as_deref().map(|node| &node.value)
    }
    pub fn peek_mut(&mut self) -> Option<&mut T> {
        self.head.as_deref_mut().map(|node| &mut node.value)
    }

    // 获取迭代器
    pub fn iter(&self) -> Iter<'_, T> {
        Iter {
            it: self.head.as_deref(),
        }
        // Iter {
        //     next: match &self.head {
        //         Link::EMPTY => None,
        //         Link::MORE(node) => Some(node.as_ref()),
        //     },
        // }
    }
    pub fn iter_mut(&mut self) -> IterMut<'_, T> {
        IterMut {
            it: self.head.as_deref_mut(),
        }
    }
}

// 添加Drop(非必要，rust会自动回收如果脱离生命周期)
impl<T: Sized> Drop for ForwardList<T> {
    fn drop(&mut self) {
        let mut option = self.head.take();
        while let Some(mut node) = option {
            option = node.next.take();
        }
    }
}

// 添加迭代器
pub struct Iter<'a, T> {
    it: Option<&'a Node<T>>,
}
pub struct IterMut<'a, T> {
    it: Option<&'a mut Node<T>>,
}

impl<'a, T> Iterator for Iter<'a, T> {
    type Item = &'a T;

    fn next(&mut self) -> Option<Self::Item> {
        self.it.map(|node| {
            // self.next = node.next.as_ref().map( |x| x.deref());
            self.it = node.next.as_deref();
            &node.value
        })

        // Option实现了clone所以不用多余的&
        // match self.next {
        //     None => None,
        //     Some(node) => {
        //         self.next = match &node.next {
        //             Link::EMPTY => None,
        //             Link::MORE(n) => Some(n.as_ref()),
        //         };
        //         Some(&node.value)
        //     }
        // }
    }
}
impl<'a, T> Iterator for IterMut<'a, T> {
    type Item = &'a mut T;

    fn next(&mut self) -> Option<Self::Item> {
        // 由于it是copy,map时会拷贝一份，同时it内涵&mut, 此时有两份&mut在同一生命周期中
        self.it.take().map(|node| {
            self.it = node.next.as_deref_mut();
            &mut node.value
        })
    }
}
